home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_format.py < prev    next >
Text File  |  2005-10-18  |  10KB  |  241 lines
  1. from test.test_support import verbose, have_unicode, TestFailed
  2. import sys
  3.  
  4. # test string formatting operator (I am not sure if this is being tested
  5. # elsewhere but, surely, some of the given cases are *not* tested because
  6. # they crash python)
  7. # test on unicode strings as well
  8.  
  9. overflowok = 1
  10.  
  11. def testformat(formatstr, args, output=None):
  12.     if verbose:
  13.         if output:
  14.             print "%s %% %s =? %s ..." %\
  15.                 (repr(formatstr), repr(args), repr(output)),
  16.         else:
  17.             print "%s %% %s works? ..." % (repr(formatstr), repr(args)),
  18.     try:
  19.         result = formatstr % args
  20.     except OverflowError:
  21.         if not overflowok:
  22.             raise
  23.         if verbose:
  24.             print 'overflow (this is fine)'
  25.     else:
  26.         if output and result != output:
  27.             if verbose:
  28.                 print 'no'
  29.             print "%s %% %s == %s != %s" %\
  30.                 (repr(formatstr), repr(args), repr(result), repr(output))
  31.         else:
  32.             if verbose:
  33.                 print 'yes'
  34.  
  35. def testboth(formatstr, *args):
  36.     testformat(formatstr, *args)
  37.     if have_unicode:
  38.         testformat(unicode(formatstr), *args)
  39.  
  40.  
  41. testboth("%.1d", (1,), "1")
  42. testboth("%.*d", (sys.maxint,1))  # expect overflow
  43. testboth("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
  44. testboth("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
  45. testboth("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
  46.  
  47. testboth("%f", (1.0,), "1.000000")
  48. # these are trying to test the limits of the internal magic-number-length
  49. # formatting buffer, if that number changes then these tests are less
  50. # effective
  51. testboth("%#.*g", (109, -1.e+49/3.))
  52. testboth("%#.*g", (110, -1.e+49/3.))
  53. testboth("%#.*g", (110, -1.e+100/3.))
  54.  
  55. # test some ridiculously large precision, expect overflow
  56. testboth('%12.*f', (123456, 1.0))
  57.  
  58. # Formatting of long integers. Overflow is not ok
  59. overflowok = 0
  60. testboth("%x", 10L, "a")
  61. testboth("%x", 100000000000L, "174876e800")
  62. testboth("%o", 10L, "12")
  63. testboth("%o", 100000000000L, "1351035564000")
  64. testboth("%d", 10L, "10")
  65. testboth("%d", 100000000000L, "100000000000")
  66.  
  67. big = 123456789012345678901234567890L
  68. testboth("%d", big, "123456789012345678901234567890")
  69. testboth("%d", -big, "-123456789012345678901234567890")
  70. testboth("%5d", -big, "-123456789012345678901234567890")
  71. testboth("%31d", -big, "-123456789012345678901234567890")
  72. testboth("%32d", -big, " -123456789012345678901234567890")
  73. testboth("%-32d", -big, "-123456789012345678901234567890 ")
  74. testboth("%032d", -big, "-0123456789012345678901234567890")
  75. testboth("%-032d", -big, "-123456789012345678901234567890 ")
  76. testboth("%034d", -big, "-000123456789012345678901234567890")
  77. testboth("%034d", big, "0000123456789012345678901234567890")
  78. testboth("%0+34d", big, "+000123456789012345678901234567890")
  79. testboth("%+34d", big, "   +123456789012345678901234567890")
  80. testboth("%34d", big, "    123456789012345678901234567890")
  81. testboth("%.2d", big, "123456789012345678901234567890")
  82. testboth("%.30d", big, "123456789012345678901234567890")
  83. testboth("%.31d", big, "0123456789012345678901234567890")
  84. testboth("%32.31d", big, " 0123456789012345678901234567890")
  85.  
  86. big = 0x1234567890abcdef12345L  # 21 hex digits
  87. testboth("%x", big, "1234567890abcdef12345")
  88. testboth("%x", -big, "-1234567890abcdef12345")
  89. testboth("%5x", -big, "-1234567890abcdef12345")
  90. testboth("%22x", -big, "-1234567890abcdef12345")
  91. testboth("%23x", -big, " -1234567890abcdef12345")
  92. testboth("%-23x", -big, "-1234567890abcdef12345 ")
  93. testboth("%023x", -big, "-01234567890abcdef12345")
  94. testboth("%-023x", -big, "-1234567890abcdef12345 ")
  95. testboth("%025x", -big, "-0001234567890abcdef12345")
  96. testboth("%025x", big, "00001234567890abcdef12345")
  97. testboth("%0+25x", big, "+0001234567890abcdef12345")
  98. testboth("%+25x", big, "   +1234567890abcdef12345")
  99. testboth("%25x", big, "    1234567890abcdef12345")
  100. testboth("%.2x", big, "1234567890abcdef12345")
  101. testboth("%.21x", big, "1234567890abcdef12345")
  102. testboth("%.22x", big, "01234567890abcdef12345")
  103. testboth("%23.22x", big, " 01234567890abcdef12345")
  104. testboth("%-23.22x", big, "01234567890abcdef12345 ")
  105. testboth("%X", big, "1234567890ABCDEF12345")
  106. testboth("%#X", big, "0X1234567890ABCDEF12345")
  107. testboth("%#x", big, "0x1234567890abcdef12345")
  108. testboth("%#x", -big, "-0x1234567890abcdef12345")
  109. testboth("%#.23x", -big, "-0x001234567890abcdef12345")
  110. testboth("%#+.23x", big, "+0x001234567890abcdef12345")
  111. testboth("%# .23x", big, " 0x001234567890abcdef12345")
  112. testboth("%#+.23X", big, "+0X001234567890ABCDEF12345")
  113. testboth("%#-+.23X", big, "+0X001234567890ABCDEF12345")
  114. testboth("%#-+26.23X", big, "+0X001234567890ABCDEF12345")
  115. testboth("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ")
  116. testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345")
  117. # next one gets two leading zeroes from precision, and another from the
  118. # 0 flag and the width
  119. testboth("%#+027.23X", big, "+0X0001234567890ABCDEF12345")
  120. # same, except no 0 flag
  121. testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345")
  122.  
  123. big = 012345670123456701234567012345670L  # 32 octal digits
  124. testboth("%o", big, "12345670123456701234567012345670")
  125. testboth("%o", -big, "-12345670123456701234567012345670")
  126. testboth("%5o", -big, "-12345670123456701234567012345670")
  127. testboth("%33o", -big, "-12345670123456701234567012345670")
  128. testboth("%34o", -big, " -12345670123456701234567012345670")
  129. testboth("%-34o", -big, "-12345670123456701234567012345670 ")
  130. testboth("%034o", -big, "-012345670123456701234567012345670")
  131. testboth("%-034o", -big, "-12345670123456701234567012345670 ")
  132. testboth("%036o", -big, "-00012345670123456701234567012345670")
  133. testboth("%036o", big, "000012345670123456701234567012345670")
  134. testboth("%0+36o", big, "+00012345670123456701234567012345670")
  135. testboth("%+36o", big, "   +12345670123456701234567012345670")
  136. testboth("%36o", big, "    12345670123456701234567012345670")
  137. testboth("%.2o", big, "12345670123456701234567012345670")
  138. testboth("%.32o", big, "12345670123456701234567012345670")
  139. testboth("%.33o", big, "012345670123456701234567012345670")
  140. testboth("%34.33o", big, " 012345670123456701234567012345670")
  141. testboth("%-34.33o", big, "012345670123456701234567012345670 ")
  142. testboth("%o", big, "12345670123456701234567012345670")
  143. testboth("%#o", big, "012345670123456701234567012345670")
  144. testboth("%#o", -big, "-012345670123456701234567012345670")
  145. testboth("%#.34o", -big, "-0012345670123456701234567012345670")
  146. testboth("%#+.34o", big, "+0012345670123456701234567012345670")
  147. testboth("%# .34o", big, " 0012345670123456701234567012345670")
  148. testboth("%#+.34o", big, "+0012345670123456701234567012345670")
  149. testboth("%#-+.34o", big, "+0012345670123456701234567012345670")
  150. testboth("%#-+37.34o", big, "+0012345670123456701234567012345670  ")
  151. testboth("%#+37.34o", big, "  +0012345670123456701234567012345670")
  152. # next one gets one leading zero from precision
  153. testboth("%.33o", big, "012345670123456701234567012345670")
  154. # base marker shouldn't change that, since "0" is redundant
  155. testboth("%#.33o", big, "012345670123456701234567012345670")
  156. # but reduce precision, and base marker should add a zero
  157. testboth("%#.32o", big, "012345670123456701234567012345670")
  158. # one leading zero from precision, and another from "0" flag & width
  159. testboth("%034.33o", big, "0012345670123456701234567012345670")
  160. # base marker shouldn't change that
  161. testboth("%0#34.33o", big, "0012345670123456701234567012345670")
  162.  
  163. # Some small ints, in both Python int and long flavors).
  164. testboth("%d", 42, "42")
  165. testboth("%d", -42, "-42")
  166. testboth("%d", 42L, "42")
  167. testboth("%d", -42L, "-42")
  168. testboth("%#x", 1, "0x1")
  169. testboth("%#x", 1L, "0x1")
  170. testboth("%#X", 1, "0X1")
  171. testboth("%#X", 1L, "0X1")
  172. testboth("%#o", 1, "01")
  173. testboth("%#o", 1L, "01")
  174. testboth("%#o", 0, "0")
  175. testboth("%#o", 0L, "0")
  176. testboth("%o", 0, "0")
  177. testboth("%o", 0L, "0")
  178. testboth("%d", 0, "0")
  179. testboth("%d", 0L, "0")
  180. testboth("%#x", 0, "0x0")
  181. testboth("%#x", 0L, "0x0")
  182. testboth("%#X", 0, "0X0")
  183. testboth("%#X", 0L, "0X0")
  184.  
  185. testboth("%x", 0x42, "42")
  186. testboth("%x", -0x42, "-42")
  187. testboth("%x", 0x42L, "42")
  188. testboth("%x", -0x42L, "-42")
  189.  
  190. testboth("%o", 042, "42")
  191. testboth("%o", -042, "-42")
  192. testboth("%o", 042L, "42")
  193. testboth("%o", -042L, "-42")
  194.  
  195. # Test exception for unknown format characters
  196. if verbose:
  197.     print 'Testing exceptions'
  198.  
  199. def test_exc(formatstr, args, exception, excmsg):
  200.     try:
  201.         testformat(formatstr, args)
  202.     except exception, exc:
  203.         if str(exc) == excmsg:
  204.             if verbose:
  205.                 print "yes"
  206.         else:
  207.             if verbose: print 'no'
  208.             print 'Unexpected ', exception, ':', repr(str(exc))
  209.     except:
  210.         if verbose: print 'no'
  211.         print 'Unexpected exception'
  212.         raise
  213.     else:
  214.         raise TestFailed, 'did not get expected exception: %s' % excmsg
  215.  
  216. test_exc('abc %a', 1, ValueError,
  217.          "unsupported format character 'a' (0x61) at index 5")
  218. if have_unicode:
  219.     test_exc(unicode('abc %\u3000','raw-unicode-escape'), 1, ValueError,
  220.              "unsupported format character '?' (0x3000) at index 5")
  221.  
  222. test_exc('%d', '1', TypeError, "int argument required")
  223. test_exc('%g', '1', TypeError, "float argument required")
  224. test_exc('no format', '1', TypeError,
  225.          "not all arguments converted during string formatting")
  226. test_exc('no format', u'1', TypeError,
  227.          "not all arguments converted during string formatting")
  228. test_exc(u'no format', '1', TypeError,
  229.          "not all arguments converted during string formatting")
  230. test_exc(u'no format', u'1', TypeError,
  231.          "not all arguments converted during string formatting")
  232.  
  233. if sys.maxint == 2**31-1:
  234.     # crashes 2.2.1 and earlier:
  235.     try:
  236.         "%*d"%(sys.maxint, -127)
  237.     except MemoryError:
  238.         pass
  239.     else:
  240.         raise TestFailed, '"%*d"%(sys.maxint, -127) should fail'
  241.